// 有一次修改机会的最长不下降子序列
// 给定一个长度为n的数组arr，和一个整数k
// 只有一次机会可以将其中连续的k个数全修改成任意一个值
// 这次机会你可以用也可以不用，请返回最长不下降子序列长度
// 1 <= k, n <= 10^5
// 1 <= arr[i] <= 10^6
// 测试链接 : https://www.luogu.com.cn/problem/P8776
// 请同学们务必参考如下代码中关于输入、输出的处理
// 这是输入输出处理效率较高的写法
// 提交以下的所有代码，可以直接通过

#include <bits/stdc++.h>

using namespace std;

const int MAXN = 100001;
int arr[MAXN];
int right[MAXN];
int ends[MAXN];
int n, k;

int read()
{
    char ch = getchar();
    int x = 0, f = 1;
    while (ch < '0' || ch > '9')
    {
        if (ch == '-') f = -1;
        ch = getchar();
    }
    while (ch >= '0' && ch <= '9')
    {
        x = 10 * x + ch - '0';
        ch = getchar();
    }
    return f * x;
}

// 求最长不上升子序列长度的二分
// ends[0...len-1]是降序的，找到<num的最左位置
// 不存在返回-1
int bs1(int len, int num)
{
    int l = 0, r = len - 1, ans = -1, m;
    while (l <= r)
    {
        m = (l + r) >> 1;
        if (::ends[m] < num)
        {
            ans = m;
            r = m - 1;
        }
        else l = m + 1;
    }
    return ans;
}

// 求最长不下降子序列长度的二分
// ends[0...len-1]是升序的，找到>num的最左位置
// 不存在返回-1
int bs2(int len, int num)
{
    int l = 0, r = len - 1, ans = -1, m;
    while (l <= r)
    {
        m = (l + r) >> 1;
        if (num < ::ends[m])
        {
            ans = m;
            r = m - 1;
        }
        else l = m + 1;
    }
    return ans;
}

// 生成辅助数组right
// right[j] :
// 一定以arr[j]做开头的情况下，arr[j...]上最长不下降子序列长度是多少
// 关键逻辑 :
// 一定以arr[j]做开头的情况下，arr[j...]上最长不下降子序列
// 就是！从n-1出发来看(从右往左遍历)，以arr[i]做结尾的情况下的最长不上升子序列
void Right()
{
    int len = 0;
    for (int i = n - 1, find; i >= 0; --i)
    {
        // bs2 : 找出第一个小于arr[i]的数的位置
        find = bs1(len, arr[i]);
        if (find == -1)
        {
            ::ends[len++] = arr[i];
            ::right[i] = len;
        }
        else
        {
            ::ends[find] = arr[i];
            ::right[i] = find + 1;
        }
    }
}

int compute()
{
    Right();
    int len = 0, ans = 0;
    for (int i = 0, j = k, find, left; j < n; ++i, ++j)
    {
        // bs2 : 找出第一个大于arr[j]的数的位置
        find = bs2(len, arr[j]);
        // left : 小于等于arr[j]的数字个数
        left = find == -1 ? len : find;
        // k : 将与arr[j]相连的前k个数变成arr[j]
        // right[j] : 以arr[j]为开头的最长不下降子序列的长度
        ans = max(ans, left + k + ::right[j]);
        // 将arr[i]这个数字放在ends数组中
        find = bs2(len, arr[i]);
        if (find == -1) ::ends[len++] = arr[i];
        else ::ends[find] = arr[i];
    }
    // 1 2 3 4 1 1 1 1，将后面的1都刷成4
    ans = max(ans, len + k);
    return ans;
}

int main()
{
    n = read(), k = read();
    for (int i = 0; i < n; ++i) arr[i] = read();
    if (k >= n) printf("%d\n", n);
    else printf("%d\n", compute());

    return 0;
}